﻿using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Transactions;
using System.Web;
using System.Web.Http;
using FimetContoDeposito.BLL;
using FimetContoDeposito.BLL.Facades;
using FimetContoDeposito.BLL.Metadata;
using FimetContoDeposito.BLL.Objects;
using FimetContoDeposito.BLL.ResultSets;
using FimetContoDeposito.DAL;
using GrayParrot.Core;
using GrayParrot.Core.Filters;
using GrayParrot.Core.Json;
using GrayParrot.Web;
using GrayParrot.Web.Controls;
using GrayParrot.Web.Formly;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace FimetContoDeposito.Controllers
{
    public class MovimentiController : ApiController
    {
        [HttpGet]
        public string LoadFieldsMovimentoToEdit()
        {
            string retValue = null;

            var m_fields = FormlyHelper.ToFormly<MovimentoMetadata>(typeof(MovimentoMetadata));

            m_fields.Hide("IDCliente");

            retValue = FormlyHelper.Serialize(m_fields);

            return retValue;
        }

        [HttpGet]
        public string[] LoadFieldsMovimentoToEdit(Guid id, Guid idCliente)
        {
            string[] retValue = new string[2] { string.Empty, string.Empty };

            FCD_MovimentiDettaglio obj = null;

            using (MovimentoDettaglioFacade m_mdf = MovimentoDettaglioFacade.Create())
            {
                ReturnValue<FCD_MovimentiDettaglio> m_rvDM = m_mdf.Get(id);
                if (m_rvDM.HasValue && m_rvDM.Value != null)
                {
                    obj = m_rvDM.Value;
                }
            }

            if (obj != null)
            {
                var m_fields = FormlyHelper.ToFormly<MovimentoMetadata>(typeof(MovimentoMetadata));

                m_fields.DefaultValue("IDCliente", idCliente.ToString());
                //m_fields.Hide("IDCliente", "HideCallback");

                #region DA CANCELLARE...
                //JsonSerializerSettings settings = new JsonSerializerSettings();
                //settings.ContractResolver = new NullToEmptyListResolver();
                //settings.Converters = new List<JsonConverter> { new Newtonsoft.Json.Converters.StringEnumConverter { CamelCaseText = false } };
                //settings.Formatting = Formatting.Indented;
                //settings.NullValueHandling = NullValueHandling.Ignore;
                //retValue[0] = JsonConvert.SerializeObject(m_fields, settings);
                #endregion

                retValue[0] = FormlyHelper.Serialize(m_fields);
                retValue[1] = JsonConvert.SerializeObject(obj);
            }

            return retValue;
        }

        [HttpGet]
        public string LoadFieldsMovimento()
        {
            string retValue = null;

            var m_fields = FormlyHelper.ToFormly<MovimentiExMetadata>(typeof(MovimentiExMetadata));

            //var m_fields = new FormlyFactory()
            //                   .AddSelect("selSport", "Sport", "", "Seleziona uno sport...", false, true, null, "/api/Common/LoadDisciplineSportRadar")
            //                   .AddRadio("radioTipologia", "Tipologia", "", "Indica se associare squadre o giocatori", false, true, "/api/elenchi/LoadTipologia")
            //                   .Create();

            JsonSerializerSettings settings = new JsonSerializerSettings();
            settings.ContractResolver = new NullToEmptyListResolver();
            settings.Converters = new List<JsonConverter> { new Newtonsoft.Json.Converters.StringEnumConverter { CamelCaseText = false } };
            settings.Formatting = Formatting.Indented;
            settings.NullValueHandling = NullValueHandling.Ignore;

            retValue = JsonConvert.SerializeObject(m_fields, settings);
            
            string m_retValue = retValue.Replace("rsFields", "fields");

            return m_retValue;
        }

        [HttpGet]
        public string LoadFieldsMovimentoCarico()
        {
            string retValue = null;

            var m_fields = FormlyHelper.ToFormly<AnagraficaDocumentiMetadataCarico>(typeof(AnagraficaDocumentiMetadataCarico));

            m_fields.Hide("IsXxxx");

            retValue = FormlyHelper.Serialize(m_fields);
            return retValue;
        }

        [HttpGet]
        public string[] LoadFieldsMovimentoCarico(Guid id)
        {
            string[] retValue = new string[2] { string.Empty, string.Empty };

            AnagraficaDocumentiMetadataCarico obj = null;

            using (MovimentiFacade m_cof = MovimentiFacade.Create())
            {
                ReturnValue<FCD_Movimenti> m_res = m_cof.Get(id, "FCD_AnagraficaDocumenti");

                if (m_res.HasValue && m_res.Value != null)
                {
                    obj = new AnagraficaDocumentiMetadataCarico();
                    obj.Customer = m_res.Value.Customer;
                    obj.DataMovimento = m_res.Value.DataMovimento.Value;
                    obj.NoteDistinta = m_res.Value.Note;

                    if (m_res.Value.FCD_AnagraficaDocumenti != null)
                    {
                        obj.DataDocumento = m_res.Value.FCD_AnagraficaDocumenti.DataDocumento;
                        obj.NumeroDocumento = m_res.Value.FCD_AnagraficaDocumenti.NumeroDocumento;
                        obj.TipoDocumento = m_res.Value.FCD_AnagraficaDocumenti.TipoDocumento;
                    }
                }
            }

            var m_fields = FormlyHelper.ToFormly<AnagraficaDocumentiMetadataCarico>(typeof(AnagraficaDocumentiMetadataCarico));
            m_fields.Hide("IsXxxx");

            retValue[0] = FormlyHelper.Serialize(m_fields);

            retValue[1] = JsonConvert.SerializeObject(obj);

            return retValue;
        }

        [HttpGet]
        public string LoadFieldsEditMovimentoCaricoSearch()
        {
            string retValue = null;

            var m_fields = FormlyHelper.ToFormly<AnagraficaDocumentiMetadataCaricoSearch>(typeof(AnagraficaDocumentiMetadataCaricoSearch));

            retValue = FormlyHelper.Serialize(m_fields);
            return retValue;
        }

        [HttpGet]
        public string LoadFieldsEditMovimentoScaricoSearch()
        {
            string retValue = null;

            var m_fields = FormlyHelper.ToFormly<AnagraficaDocumentoMetadataScaricoSearch>(typeof(AnagraficaDocumentoMetadataScaricoSearch));

            retValue = FormlyHelper.Serialize(m_fields);
            return retValue;
        }

        [HttpGet]
        public string LoadFieldsMovimentoScarico()
        {
            string retValue = null;

            var m_fields = FormlyHelper.ToFormly<AnagraficaDocumentiMetadataScarico>(typeof(AnagraficaDocumentiMetadataScarico));

            //m_fields.Hide("Prenotata");
            //m_fields.Hide("Fornitore");

            retValue = FormlyHelper.Serialize(m_fields);

            return retValue;
        }

        [HttpGet]
        public string[] LoadFieldsMovimentoScarico(Guid id)
        {
            string[] retValue = new string[2] { string.Empty, string.Empty };

            AnagraficaDocumentiMetadataScarico obj = null;

            using (MovimentiFacade m_cof = MovimentiFacade.Create())
            {
                ReturnValue<FCD_Movimenti> m_res = m_cof.Get(id, "FCD_AnagraficaDocumenti");

                if (m_res.HasValue && m_res.Value != null)
                {
                    obj = new AnagraficaDocumentiMetadataScarico();
                    obj.Customer = m_res.Value.Customer;
                    obj.DataMovimento = m_res.Value.DataMovimento.Value;
                    obj.RiferimentoCliente = m_res.Value.RiferimentoCliente;
                    obj.NoteDistinta = m_res.Value.Note;
                    obj.Colore = m_res.Value.CodiceColore;
                    obj.Priorità = m_res.Value.Priorita.Value;

                    if (m_res.Value.DataConsegna.HasValue)
                    {
                        obj.DataConsegna = m_res.Value.DataConsegna.Value;
                    }

                    if (m_res.Value.FCD_AnagraficaDocumenti != null)
                    {
                        obj.DataDocumento = m_res.Value.FCD_AnagraficaDocumenti.DataDocumento;
                        obj.NumeroDocumento = m_res.Value.FCD_AnagraficaDocumenti.NumeroDocumento;
                        obj.TipoDocumento = m_res.Value.FCD_AnagraficaDocumenti.TipoDocumento;
                    }
                }
            }

            var m_fields = FormlyHelper.ToFormly<AnagraficaDocumentiMetadataScarico>(typeof(AnagraficaDocumentiMetadataScarico));
            m_fields.DefaultValue<DateTime>("DataConsegna", obj.DataConsegna);

            retValue[0] = FormlyHelper.Serialize(m_fields);

            retValue[1] = JsonConvert.SerializeObject(obj);

            return retValue;
        }

        [HttpGet]
        public string LoadFieldsMovimentoCaricoDetail()
        {
            string retValue = null;

            var m_fields = FormlyHelper.ToFormly<MovimentiDetailMetadata>(typeof(MovimentiDetailMetadata));

            retValue = FormlyHelper.Serialize(m_fields);

            return retValue;
        }

        private DateTime ConvertDateTimeFromGMT(string gmtDateTime, string timezoneString)
        {
            DateTime retValue = default(DateTime);

            string[] timezones = timezoneString.Split(new char[] { ',' });

            foreach (string s in timezones)
            {
                gmtDateTime = gmtDateTime.Replace(s, "").Trim();
            }

            string format = "ddd MMM dd yyyy HH:mm:ss 'GMT'K";

            bool validFormat = DateTime.TryParseExact(gmtDateTime, format, CultureInfo.InvariantCulture, DateTimeStyles.None, out retValue);

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage Edit(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            Guid m_id = Guid.Parse(json.Id.ToString());
            decimal m_quantita = decimal.Parse(json.Quantita.ToString());
            Guid m_idMovimento = Guid.Parse(json.IdMovimento.ToString());
            Guid m_idArticolo = Guid.Parse(json.Articolo.ToString());

            // leggo il movimento per capire se è carico o scarico...
            TipoMovimento m_tipoMovimento = TipoMovimento.Carico;
            using (MovimentiFacade m_mf = MovimentiFacade.Create())
            {
                ReturnValue<FCD_Movimenti> m_rvMov =  m_mf.Get(m_idMovimento);
                if (m_rvMov.HasValue && m_rvMov.Value != null)
                {
                    m_tipoMovimento = (TipoMovimento)m_rvMov.Value.TipoMovimento;
                }
            }

            ReturnValue<bool> m_rvBool = new ReturnValue<bool>(false);

            ElaborazioneMovimentiManager m_emm = new ElaborazioneMovimentiManager();
            m_rvBool = m_emm.ModificaElemento(m_id, m_idMovimento, m_idArticolo, m_quantita, m_tipoMovimento);
            if (m_rvBool.HasValue && m_rvBool.Value)
            {
                retValue = Request.CreateResponseMessage("Modifica elemento non effettuata", ResponseMessageTypes.Success);
            }
            else
            {
                if (m_rvBool.HasValue && !m_rvBool.Value)
                {
                    retValue = Request.CreateResponseMessage(m_rvBool.Message, ResponseMessageTypes.Warning);
                }
                else
                {
                    if (m_rvBool.HasError)
                    {
                        retValue = Request.CreateResponseMessage(m_rvBool.Error.Message, ResponseMessageTypes.Error);
                    }
                    else
                    {
                        retValue = Request.CreateResponseMessage("Si è verificata una situazione imprevista. Modifica elemento non effettuata", ResponseMessageTypes.Warning);
                    }
                }
            }

            return retValue;
        }

        /// <summary>
        /// Cancellas the movimento.
        /// </summary>
        /// <param name="data">The data.</param>
        /// <returns>ATTENZIONE: Verificare se possibile utilizzarlo sia nella maschera di carico che di scarico</returns>
        [HttpPost]
        public System.Net.Http.HttpResponseMessage CancellaMovimento(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            Guid m_id = Guid.Parse(json.id.ToString());
            TipoMovimento m_tipomovimento = (TipoMovimento)json.tipoMovimento;

            ReturnValue<bool> m_rvCheck = new ReturnValue<bool>(false);
            ElaborazioneMovimentiManager m_emm = new ElaborazioneMovimentiManager();

            if (m_tipomovimento == TipoMovimento.Carico)
            {
                m_rvCheck = m_emm.CancellaMovimentoCarico(m_id);
            }
            else
            {
                m_rvCheck = m_emm.CancellaMovimentoScarico(m_id);
            }

            if (m_rvCheck.HasValue && m_rvCheck.Value)
            {
                retValue = Request.CreateResponseMessage("Cancellazione movimento effettuata", ResponseMessageTypes.Success);
            }
            else
            {
                if (m_rvCheck.HasValue && !m_rvCheck.Value)
                {
                    retValue = Request.CreateResponseMessage(m_rvCheck.Message, ResponseMessageTypes.Warning);
                }
                else
                {
                    if (m_rvCheck.HasError)
                    {
                        retValue = Request.CreateResponseMessage(m_rvCheck.Error.Message, ResponseMessageTypes.Error);
                    }
                }
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage CancellaElemento(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            Guid m_id = Guid.Parse(json.id.ToString());
            TipoMovimento m_tipomovimento = (TipoMovimento)json.tipoMovimento;

            ElaborazioneMovimentiManager m_emm = new ElaborazioneMovimentiManager();
            ReturnValue<bool> m_rvCancellaElemento = new ReturnValue<bool>(false);

            if (m_tipomovimento == TipoMovimento.Carico)
            {
                m_rvCancellaElemento = m_emm.CancellaElementoCarico(m_id);
            }
            else
            {
               
                m_rvCancellaElemento = m_emm.CancellaElementoScarico(m_id);
            }

            //
            if (m_rvCancellaElemento.HasValue && m_rvCancellaElemento.Value)
            {
                retValue = Request.CreateResponseMessage("Cancellazione Elemento Effettuata", ResponseMessageTypes.Info);
            }
            else
            {
                if (m_rvCancellaElemento.HasError)
                {
                    retValue = Request.CreateResponseMessage(m_rvCancellaElemento.Error.Message, ResponseMessageTypes.Error);
                }
                else
                {
                    string msg = "Non è stato possibile eseguire l'operazione richiesta";
                    if (!string.IsNullOrWhiteSpace(m_rvCancellaElemento.Message))
                    {
                        msg = m_rvCancellaElemento.Message;
                    }

                    retValue = Request.CreateResponseMessage(msg, ResponseMessageTypes.Warning);
                }
            }

            return retValue;
        }

        private void CalcoloContributo(Guid m_idArticolo, decimal quantitaDaScaricare)
        {

        }

        private System.Net.Http.HttpResponseMessage EvadiRichiestaScaricoCliente(Guid idMovimento)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            ReturnValue<FCD_MovimentiDettaglio> m_resultMovD = new ReturnValue<FCD_MovimentiDettaglio>(null);
            using (MovimentoDettaglioFacade m_mdf = MovimentoDettaglioFacade.Create())
            {
                ReturnValue<IQueryable<FCD_MovimentiDettaglio>> m_rvDettagli = m_mdf.GetDettagliMovimento(idMovimento);

                if (m_rvDettagli.HasValue && m_rvDettagli.Value != null)
                {
                    List<FCD_MovimentiDettaglio> m_dettagli = m_rvDettagli.Value.ToList();
                    
                    ElaborazioneMovimentiManager m_emm = new ElaborazioneMovimentiManager();

                    foreach (FCD_MovimentiDettaglio m_movD in m_dettagli)
                    {
                        List<MovimentoBag> m_scarichi = m_emm.RichiestaScarico(m_movD.Articolo, m_movD.Quantita);

                        if ((m_scarichi != null) && (m_scarichi.Count() > 0))
                        {
                            using (DettaglioScaricoBollaFacade m_dsbf = DettaglioScaricoBollaFacade.Create())
                            {
                                foreach (MovimentoBag bag in m_scarichi)
                                {
                                    FCD_DettaglioScaricoBolla m_dsb = new FCD_DettaglioScaricoBolla();
                                    m_dsb.IdBollaCarico = bag.Id;
                                    m_dsb.Quantita = bag.QuantitaDaScaricare;
                                    m_dsb.IdScarico = m_movD.Id;
                                    //

                                    m_mdf.SetQuantitaDisponibile(bag.Id, bag.QuantitaDaScaricare);

                                    ContributoScarico m_contributo = m_emm.CalcolaContributoScarico(m_movD.Articolo, m_movD.Id, m_movD.Quantita);
                                    if (m_contributo != null)
                                    {
                                        m_mdf.SetInformazioniContributo(m_movD.IdMovimento, m_contributo);
                                    }

                                    //
                                    ReturnValue<bool> resultScarico = m_dsbf.Add(m_dsb);

                                    if (resultScarico.HasValue)
                                    {
                                        using (MovimentiFacade m_mf = MovimentiFacade.Create())
                                        {
                                            m_mf.ImpostaStatoCarico(bag.IdMovimentoCarico);
                                        }

                                        if (resultScarico.Value)
                                        {
                                            NameValue<string, Guid> m_resp = new NameValue<string, Guid>();
                                            m_resp.value = m_movD.Id;
                                            m_resp.name = "Scarico Effettuato";
                                            retValue = Request.CreateResponse(HttpStatusCode.OK, m_resp);
                                        }
                                    }
                                    else
                                    {
                                        NameValue<string, Guid> m_resp = new NameValue<string, Guid>();
                                        m_resp.value = Guid.Empty;
                                        m_resp.name = "";
                                        retValue = Request.CreateResponse(HttpStatusCode.NotAcceptable, m_resp);
                                    }
                                }
                            }
                        }
                        else
                        {
                            retValue = Request.CreateResponseMessage("Scarico non effettuato.\nNon sono presenti movimenti di carico relativi all'articolo indicato.", ResponseMessageTypes.Info);
                        }
                    }
                }
                else
                {
                    retValue = Request.CreateResponseMessage("Scarico non effettuato.\nMovimento di scarico non trovato o non corretto.", ResponseMessageTypes.Info);
                }
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage SalvaElementoScarico(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            string m_codiceArticolo = json.data.codiceArticolo;

            using (TransactionScope scope = new TransactionScope())
            {
                using (MovimentoDettaglioFacade m_mdf = MovimentoDettaglioFacade.Create())
                {
                    Guid m_idArticolo = Guid.Parse(json.data.Articolo.ToString());
                    decimal m_quantita = json.data.Quantita;

                    FCD_MovimentiDettaglio m_movD = new FCD_MovimentiDettaglio();
                    m_movD.Articolo = m_idArticolo;
                    m_movD.Id = Guid.NewGuid();
                    m_movD.IdMovimento = json.idMovimento;
                    m_movD.Quantita = m_quantita;
                    //m_movD.CodiceColore = json.data.Colore;
                    //m_movD.Priorita = (json.data.Priorita == null ? false : true);
                    m_movD.Note = json.data.NoteMovimento;

                    ReturnValue<bool> resultD = m_mdf.Add(m_movD);

                    if (resultD.HasValue)
                    {
                        ElaborazioneMovimentiManager m_emm = new ElaborazioneMovimentiManager();
                        List<MovimentoBag> m_scarichi = m_emm.RichiestaScarico(m_idArticolo, m_quantita);

                        StringBuilder m_risultatoScarico = new StringBuilder();
                        if ((m_scarichi != null) && (m_scarichi.Count() > 0))
                        {
                            StringBuilder sb_rifDocCarico = new StringBuilder();

                            using (DettaglioScaricoBollaFacade m_dsbf = DettaglioScaricoBollaFacade.Create())
                            {
                                foreach (MovimentoBag bag in m_scarichi)
                                {
                                    sb_rifDocCarico.AppendFormat("{0} del {1}", bag.NumeroDocumento, bag.DataDocumento.ToShortDateString());

                                    FCD_DettaglioScaricoBolla m_dsb = new FCD_DettaglioScaricoBolla();
                                    m_dsb.IdBollaCarico = bag.Id;
                                    m_dsb.Quantita = bag.QuantitaDaScaricare;
                                    m_dsb.IdScarico = m_movD.Id;

                                    m_mdf.SetQuantitaDisponibile(bag.Id, bag.QuantitaDaScaricare);

                                    ContributoScarico m_contributo = m_emm.CalcolaContributoScarico(m_idArticolo, bag.Id, m_quantita);
                                    if (m_contributo != null)
                                    {
                                        m_mdf.SetInformazioniContributo(bag.Id, m_contributo);
                                    }

                                    if (bag.Chiuso)
                                    {
                                        m_mdf.SetChiuso(bag.Id);
                                    }
                                    //else
                                    //{
                                    //    m_mdf.SetQuantitaDisponibile(bag.Id, bag.QuantitaDaScaricare);
                                    //}

                                    ReturnValue<bool> resultScarico = m_dsbf.Add(m_dsb);

                                    if (resultScarico.HasValue && resultScarico.Value)
                                    {
                                        using (MovimentiFacade m_mf = MovimentiFacade.Create())
                                        {
                                            m_mf.ImpostaStatoCarico(bag.IdMovimentoCarico);
                                        }

                                        if (resultScarico.Value)
                                        {
                                            m_risultatoScarico.AppendFormat("Scarico Effettuato. Articolo: {0}", m_codiceArticolo);
                                        }
                                    }
                                    else
                                    {
                                        if (resultScarico.HasError)
                                        {
                                            m_risultatoScarico.AppendFormat("Errore nello scarico. Articolo: {0}, Errore: {1}", m_codiceArticolo, resultScarico.Error.Message);
                                        }
                                        else
                                        {
                                            m_risultatoScarico.AppendFormat("Scarico non effettuato. Articolo: {0}, Msg: {1}", m_codiceArticolo, resultScarico.Message);
                                        }
                                    }
                                }
                            }

                            DocumentoScaricoResponse m_dsr = new DocumentoScaricoResponse();
                            m_dsr.IdMovimento = m_movD.Id;
                            m_dsr.EsitoScarico = m_risultatoScarico.ToString();
                            m_dsr.RiferimentoDocumentiCarico = sb_rifDocCarico.ToString();

                            retValue = Request.CreateResponse(HttpStatusCode.OK, m_dsr);
                        }
                        else
                        {
                            retValue = Request.CreateResponseMessage("Scarico non effettuato.\nNon sono presenti movimenti di carico relativi all'articolo indicato.", ResponseMessageTypes.Info);
                        }
                    }
                    else
                    {
                        if (resultD.HasError)
                        {
                            retValue = Request.CreateResponseMessage(resultD.Error.Message, ResponseMessageTypes.Error);
                        }
                    }
                }

                scope.Complete();
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage SalvaDatiDocumentoScarico(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            Guid m_idCustomer = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.data.Customer.ToString()));
            Guid m_idTipoDoc = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.data.TipoDocumento.ToString()));

            DateTime m_dataDocumento = DateTime.Parse(json.data.DataDocumento.ToString());

            DateTime m_dataMovimento = DateTime.Now;
            string m_dataMovimentoS = json.data.DataMovimento.ToString();
            if (!string.IsNullOrWhiteSpace(m_dataMovimentoS))
            {
                m_dataMovimento = DateTime.Parse(m_dataMovimentoS);
                //m_dataMovimento = ConvertDateTimeFromGMT(json.data.DataMovimento.ToString(), "(ora legale Europa occidentale),(ora solare Europa occidentale)");
            }

            DateTime? m_dataConsegna = null;
            if (json.data.DataConsegna != null)
            {
                string m_dataConsegnaS = json.data.DataConsegna.ToString();
                if (!string.IsNullOrWhiteSpace(m_dataConsegnaS))
                {
                    m_dataConsegna = DateTime.Parse(m_dataConsegnaS);
                }
            }

            using (TransactionScope scope = new TransactionScope())
            {
                FCD_AnagraficaDocumenti m_anagDdt = new FCD_AnagraficaDocumenti();
                m_anagDdt.Id = Guid.NewGuid();
                m_anagDdt.NumeroDocumento = json.data.NumeroDocumento;
                m_anagDdt.DataDocumento = m_dataDocumento;
                m_anagDdt.Customer = m_idCustomer;
                m_anagDdt.TipoDocumento = m_idTipoDoc;

                ReturnValue<bool> m_resultDDT = null;
                using (AnagraficaDocumentiFacade m_addt = AnagraficaDocumentiFacade.Create())
                {
                    m_resultDDT = m_addt.Add(m_anagDdt);

                    if (m_resultDDT.HasValue)
                    {
                        if (m_resultDDT.Value)
                        {
                            using (MovimentiFacade m_dc = MovimentiFacade.Create())
                            {
                                // creo il movimento di carico...
                                FCD_Movimenti m_mov = new FCD_Movimenti();
                                m_mov.Id = Guid.NewGuid();
                                m_mov.IdDdt = m_anagDdt.Id;
                                m_mov.NumeroDocumento = json.data.NumeroDocumento;
                                m_mov.DataRegistrazione = DateTime.Now;
                                m_mov.DataMovimento = m_dataMovimento;
                                m_mov.TipoOperazione = (short)TipoOperazione.Deposito;
                                m_mov.TipoMovimento = (short)TipoMovimento.Scarico;
                                m_mov.Customer = m_idCustomer;
                                m_mov.DataConsegna = m_dataConsegna;
                                m_mov.RiferimentoCliente = json.data.RiferimentoCliente;
                                m_mov.Note = json.data.Note;
                                m_mov.CodiceColore = json.data.CodiceColore;
                                m_mov.Priorita = (json.data.Priorita == null ? false : true);

                                ReturnValue<bool> result = m_dc.Add(m_mov);

                                if (result.HasValue)
                                {
                                    if (result.Value)
                                    {
                                        ObjectIdentifierBag bag = new ObjectIdentifierBag(m_mov.Id);
                                        string msg = JsonConvert.SerializeObject(bag);
                                        retValue = Request.CreateResponse(HttpStatusCode.OK, msg);
                                    }
                                }
                                else
                                {
                                    if (result.HasError)
                                    {
                                        retValue = Request.CreateResponseMessage(result.Error.Message, ResponseMessageTypes.Info);
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        if (m_resultDDT.HasError)
                        {
                            retValue = Request.CreateResponseMessage(m_resultDDT.Error.Message, ResponseMessageTypes.Info);
                        }
                    }

                    scope.Complete();
                }
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage NuovoMovimentoScarico(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            Guid m_idCustomer = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.data.Customer.ToString()));
            Guid m_idTipoDoc = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.data.TipoDocumento.ToString()));

            DateTime m_dataDocumento = DateTime.ParseExact(json.data.DataDocumento.ToString(), "dd/MM/yyyy", CultureInfo.CurrentCulture);

            DateTime m_dataMovimento = DateTime.Now;
            if (!string.IsNullOrWhiteSpace(json.data.DataMovimento.ToString()))
            {
                m_dataMovimento = ConvertDateTimeFromGMT(json.data.DataMovimento.ToString(), "(ora legale Europa occidentale),(ora solare Europa occidentale)");
            }

            using (TransactionScope scope = new TransactionScope())
            {
                FCD_AnagraficaDocumenti m_anagDdt = new FCD_AnagraficaDocumenti();
                m_anagDdt.Id = Guid.NewGuid();
                m_anagDdt.NumeroDocumento = json.data.NumeroDocumento;
                m_anagDdt.DataDocumento = m_dataDocumento;
                m_anagDdt.Customer = m_idCustomer;
                m_anagDdt.TipoDocumento = m_idTipoDoc;

                ReturnValue<bool> m_resultDDT = null;
                using (AnagraficaDocumentiFacade m_addt = AnagraficaDocumentiFacade.Create())
                {
                    m_resultDDT = m_addt.Add(m_anagDdt);
                }

                if (m_resultDDT.HasValue)
                {
                    if (m_resultDDT.Value)
                    {
                        string m_messaggio = string.Empty;

                        using (MovimentiFacade m_dc = MovimentiFacade.Create())
                        {
                            // creo il movimento di carico...
                            FCD_Movimenti m_mov = new FCD_Movimenti();
                            m_mov.Id = Guid.NewGuid();
                            m_mov.IdDdt = m_anagDdt.Id;
                            m_mov.NumeroDocumento = json.data.NumeroDocumento;
                            m_mov.DataRegistrazione = DateTime.Now;
                            m_mov.DataMovimento = m_dataMovimento;
                            m_mov.TipoOperazione = (short)TipoOperazione.Deposito;
                            m_mov.TipoMovimento = (short)TipoMovimento.Scarico;
                            m_mov.Customer = m_idCustomer;
                            //m_mov.Note = detail.Note;

                            ReturnValue<bool> result = m_dc.Add(m_mov);

                            if (result.HasValue)
                            {
                                if (result.Value)
                                {
                                    // aggiungo i dettagli...
                                    using (MovimentoDettaglioFacade m_mdf = MovimentoDettaglioFacade.Create())
                                    {
                                        foreach (var detail in json.data.Details)
                                        {
                                            FCD_MovimentiDettaglio m_movD = new FCD_MovimentiDettaglio();
                                            m_movD.Articolo = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(detail.Articolo));
                                            m_movD.Id = Guid.NewGuid();
                                            m_movD.IdMovimento = m_mov.Id;
                                            m_movD.Quantita = detail.Quantita;

                                            ReturnValue<bool> resultD = m_mdf.Add(m_movD);

                                            if (resultD.HasValue)
                                            {
                                                m_messaggio += "Creato movimento di scarico per articolo:";
                                            }
                                            else
                                            {
                                                if (result.HasError)
                                                {
                                                    m_messaggio += string.Format("Errore movimento di scarico per articolo: {0}", result.Error.Message);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            else
                            {
                                if (result.HasError)
                                {
                                    m_messaggio += string.Format("Errore movimento di scarico per articolo: {0}", result.Error.Message);
                                }
                            }

                            retValue = Request.CreateResponseMessage(m_messaggio, ResponseMessageTypes.Info);
                        }
                    }

                    scope.Complete();

                    // proviamo ad elaborare lo scarico andando a chiudere i vari documenti
                    // di carico ancora disponibili per l'articolo...
                    //foreach (var detail in json.data.Details)
                    //{
                    //    Guid idArticolo = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(detail.Articolo));
                    //    decimal quantita = detail.Quantita;

                    //    ElaboraRichiestaScarico(idArticolo, quantita);
                    //}
                }
                else
                {
                    if (m_resultDDT.HasError)
                    {
                        string m_msg = string.Format("Errore nella creazione del documento DDT. {0}", m_resultDDT.Error.Message);
                        retValue = Request.CreateResponseMessage(m_msg, ResponseMessageTypes.Error);
                    }
                }
            }

            return retValue;
        }

        /// <summary>
        /// Elaboras the richiesta scarico.
        /// http://stackoverflow.com/questions/11841486/datatables-drill-down-rows-with-nested-independent-table/12409660#12409660
        /// https://jsfiddle.net/karlnicholas/2gc3r7vv/
        /// </summary>
        /// <param name="data">The data.</param>
        /// <returns></returns>
        [HttpPost]
        public List<MovimentoBag> ElaboraRichiestaScarico(JObject data)
        {
            List<MovimentoBag> retValue = new List<MovimentoBag>();

            dynamic json = data;
            Guid m_idArticolo = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.idArticolo.ToString()));
            decimal m_quantitaRichiestaDaScaricare = json.quantitaRichiestaDaScaricare;

            using (MovimentiFacade m_mf = MovimentiFacade.Create())
            {
                ReturnValue<IQueryable<MovimentoBag>> m_rt = m_mf.GetPropostaScarico(m_idArticolo);

                if (m_rt.HasValue)
                {
                    List<MovimentoBag> m_movimentiDiCaricoProposti = m_rt.Value.ToList();

                    decimal m_qr = m_quantitaRichiestaDaScaricare;

                    foreach (MovimentoBag bag in m_movimentiDiCaricoProposti)
                    {
                        decimal m_quantitaDisponibile = bag.Quantita - bag.Prenotata;

                        if (m_qr == 0)
                        {
                            break;
                        }

                        if (m_quantitaDisponibile >= m_qr)
                        {
                            bag.QuantitaDaScaricare = m_qr;
                            m_qr = 0;

                            //m_qr = m_qr - m_quantitaRichiestaDaScaricare;
                        }
                        else
                        {
                            bag.QuantitaDaScaricare = m_quantitaDisponibile;
                            m_qr = m_qr - m_quantitaDisponibile;

                            // la quantita del movimento è < della quantita richiesta da scaricare
                            // quindi esaurisco il movimento di carico e lo chiudo
                            bag.Chiuso = true;
                        }

                        retValue.Add(bag);
                    }
                }
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage NuovoMovimentoCarico(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            Guid m_idCustomer = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.data.Customer.ToString()));
            Guid m_idTipoDoc = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.data.TipoDocumento.ToString()));

            DateTime m_dataDocumento = DateTime.ParseExact(json.data.DataDocumento.ToString(), "dd/MM/yyyy", CultureInfo.CurrentCulture);

            DateTime m_dataMovimento = DateTime.Now;
            if (!string.IsNullOrWhiteSpace(json.data.DataMovimento.ToString()))
            {
                m_dataMovimento = ConvertDateTimeFromGMT(json.data.DataMovimento.ToString(), "(ora legale Europa occidentale),(ora solare Europa occidentale)");
            }

            using (TransactionScope scope = new TransactionScope())
            {
                FCD_AnagraficaDocumenti m_anagDdt = new FCD_AnagraficaDocumenti();
                m_anagDdt.Id = Guid.NewGuid();
                m_anagDdt.NumeroDocumento = json.data.NumeroDocumento;
                m_anagDdt.DataDocumento = m_dataDocumento;
                m_anagDdt.Customer = m_idCustomer;
                m_anagDdt.TipoDocumento = m_idTipoDoc;

                ReturnValue<bool> m_resultDDT = null;
                using (AnagraficaDocumentiFacade m_addt = AnagraficaDocumentiFacade.Create())
                {
                    m_resultDDT = m_addt.Add(m_anagDdt);
                }

                if (m_resultDDT.HasValue)
                {
                    if (m_resultDDT.Value)
                    {
                        string m_messaggio = string.Empty;

                        using (MovimentiFacade m_dc = MovimentiFacade.Create())
                        {
                            // creo il movimento di carico...
                            FCD_Movimenti m_mov = new FCD_Movimenti();
                            m_mov.Id = Guid.NewGuid();
                            m_mov.IdDdt = m_anagDdt.Id;
                            m_mov.NumeroDocumento = json.data.NumeroDocumento;
                            m_mov.DataRegistrazione = DateTime.Now;
                            m_mov.DataMovimento = m_dataMovimento;
                            m_mov.TipoOperazione = (short)TipoOperazione.Deposito;
                            m_mov.TipoMovimento = (short)TipoMovimento.Carico;
                            m_mov.Customer = m_idCustomer;
                            //m_mov.Note = detail.Note;

                            ReturnValue<bool> result = m_dc.Add(m_mov);

                            if (result.HasValue)
                            {
                                if (result.Value)
                                {
                                    // aggiungo i dettagli...
                                    using (MovimentoDettaglioFacade m_mdf = MovimentoDettaglioFacade.Create())
                                    {
                                        foreach (var detail in json.data.Details)
                                        {
                                            FCD_MovimentiDettaglio m_movD = new FCD_MovimentiDettaglio();
                                            m_movD.Articolo = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(detail.Articolo));
                                            m_movD.Id = Guid.NewGuid();
                                            m_movD.IdMovimento = m_mov.Id;
                                            m_movD.Note = detail.Note;
                                            m_movD.Prenotata = detail.Prenotata;
                                            m_movD.Quantita = detail.Quantita;
                                            m_movD.QuantitaDisponibile = detail.Quantita;

                                            ReturnValue<bool> resultD = m_mdf.Add(m_movD);

                                            if (resultD.HasValue)
                                            {
                                                m_messaggio += "Creato movimento di carico per articolo:";
                                            }
                                            else
                                            {
                                                if (result.HasError)
                                                {
                                                    m_messaggio += string.Format("Errore movimento di carico per articolo: {0}", result.Error.Message);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            else
                            {
                                if (result.HasError)
                                {
                                    m_messaggio += string.Format("Errore movimento di carico per articolo: {0}", result.Error.Message);
                                }
                            }

                            retValue = Request.CreateResponseMessage(m_messaggio, ResponseMessageTypes.Info);
                        }
                    }

                    scope.Complete();
                }
                else
                {
                    if (m_resultDDT.HasError)
                    {
                        string m_msg = string.Format("Errore nella creazione del documento DDT. {0}", m_resultDDT.Error.Message);
                        retValue = Request.CreateResponseMessage(m_msg, ResponseMessageTypes.Error);
                    }
                }
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage LoadCronologia(DTParameters data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            using (MovimentiFacade m_dc = MovimentiFacade.Create())
            {
                ReturnValue<IQueryable<Cronologia>> m_objs = m_dc.GetMovimentiBags();

                DTResult<Cronologia> result = DTResult<Cronologia>.Empty("Nessun elemento trovato");
                if (m_objs.HasValue)
                {
                    MovimentiResultSet m_rs = new MovimentiResultSet(data, m_objs.Value);
                    result = m_rs.GetResult();
                }
                else
                {
                    if (m_objs.HasError)
                    {
                        result.Message.MessageType = MessageTypes.Error;
                        result.Message.Message = m_objs.Error.Message;
                    }
                }

                retValue = Request.CreateResponse(HttpStatusCode.OK, result);
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage LoadDettaglioCronologia(DettaglioCronologiaParams data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            using (MovimentiFacade m_dc = MovimentiFacade.Create())
            {
                ReturnValue<IQueryable<CronologiaDettaglio>> m_objs = m_dc.GetMovimentiDettaglioBags(data.IDMovimento);

                DTResult<CronologiaDettaglio> result = DTResult<CronologiaDettaglio>.Empty("Nessun elemento trovato");
                if (m_objs.HasValue)
                {
                    CronologiaDettaglioResultSet m_rs = new CronologiaDettaglioResultSet(data, m_objs.Value);
                    result = m_rs.GetResult();
                }
                else
                {
                    if (m_objs.HasError)
                    {
                        result.Message.MessageType = MessageTypes.Error;
                        result.Message.Message = m_objs.Error.Message;
                    }
                }

                retValue = Request.CreateResponse(HttpStatusCode.OK, result);
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage GetArticolo(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;
            Guid m_id = Guid.Parse(json.id.ToString());

            FCD_AnagraficaArticoli m_obj = null;
            using (AnagraficaArticoliFacade m_aaf = AnagraficaArticoliFacade.Create())
            {
                ReturnValue<FCD_AnagraficaArticoli> m_resultArticolo = m_aaf.Get(m_id);
                if (m_resultArticolo.HasValue)
                {
                    m_obj = m_resultArticolo.Value;
                }
            }

            retValue = Request.CreateResponse(HttpStatusCode.OK, m_obj);
            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage CancellaDatiDocumentoMovimento(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            Guid m_idMovimento = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.id.ToString()));

            using (TransactionScope scope = new TransactionScope())
            {
                using (MovimentiFacade m_dc = MovimentiFacade.Create())
                {
                    ReturnValue<bool> m_movRet = m_dc.SetCancellato(m_idMovimento);

                    if (m_movRet.HasValue)
                    {
                        if (m_movRet.Value)
                        {
                            retValue = Request.CreateResponseMessage("Movimento Cancellato", ResponseMessageTypes.Success);
                        }
                        else
                        {
                            retValue = Request.CreateResponseMessage("Movimento non cancellato", ResponseMessageTypes.Warning);
                        }
                    }
                    else
                    {
                        if (m_movRet.HasError)
                        {
                            retValue = Request.CreateResponseMessage(m_movRet.Error.Message, ResponseMessageTypes.Error);
                        }
                    }
                }

                scope.Complete();
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage SalvaDatiDocumentoScaricoCliente(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            Guid m_idCustomer = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.data.Customer.ToString()));
            Guid m_idTipoDoc = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.data.TipoDocumento.ToString()));

            DateTime m_dataDocumento = DateTime.Parse(json.data.DataDocumento.ToString());

            DateTime m_dataMovimento = DateTime.Now;
            string m_dataMovimentoS = json.data.DataMovimento.ToString();
            if (!string.IsNullOrWhiteSpace(m_dataMovimentoS))
            {
                m_dataMovimento = DateTime.Parse(m_dataMovimentoS);
                //m_dataMovimento = ConvertDateTimeFromGMT(json.data.DataMovimento.ToString(), "(ora legale Europa occidentale),(ora solare Europa occidentale)");
            }

            DateTime? m_dataConsegna = null;
            string m_dataConsegnaS = json.data.DataConsegna.ToString();
            if (!string.IsNullOrWhiteSpace(m_dataConsegnaS))
            {
                m_dataConsegna = DateTime.Parse(m_dataConsegnaS);
            }

            using (TransactionScope scope = new TransactionScope())
            {
                FCD_AnagraficaDocumenti m_anagDdt = new FCD_AnagraficaDocumenti();
                m_anagDdt.Id = Guid.NewGuid();
                m_anagDdt.NumeroDocumento = json.data.NumeroDocumento;
                m_anagDdt.DataDocumento = m_dataDocumento;
                m_anagDdt.Customer = m_idCustomer;
                m_anagDdt.TipoDocumento = m_idTipoDoc;

                ReturnValue<bool> m_resultDDT = null;
                using (AnagraficaDocumentiFacade m_addt = AnagraficaDocumentiFacade.Create())
                {
                    m_resultDDT = m_addt.Add(m_anagDdt);

                    if (m_resultDDT.HasValue)
                    {
                        if (m_resultDDT.Value)
                        {
                            using (MovimentiFacade m_dc = MovimentiFacade.Create())
                            {
                                // creo il movimento di carico...
                                FCD_Movimenti m_mov = new FCD_Movimenti();
                                m_mov.Id = Guid.NewGuid();
                                m_mov.IdDdt = m_anagDdt.Id;
                                m_mov.NumeroDocumento = json.data.NumeroDocumento;
                                m_mov.DataRegistrazione = DateTime.Now;
                                m_mov.DataMovimento = m_dataMovimento;
                                m_mov.TipoOperazione = (short)TipoOperazione.Deposito;
                                m_mov.TipoMovimento = (short)TipoMovimento.OrdineScarico;
                                m_mov.Customer = m_idCustomer;
                                m_mov.DataConsegna = m_dataConsegna;
                                m_mov.RiferimentoCliente = json.data.RiferimentoCliente;
                                m_mov.Note = json.data.Note;
                                m_mov.DataRegistrazioneUtente = DateTime.Now;
                                m_mov.RegistratoDaUtente = true;

                                ReturnValue<bool> result = m_dc.Add(m_mov);

                                if (result.HasValue)
                                {
                                    if (result.Value)
                                    {
                                        ObjectIdentifierBag bag = new ObjectIdentifierBag(m_mov.Id);
                                        string msg = JsonConvert.SerializeObject(bag);
                                        retValue = Request.CreateResponse(HttpStatusCode.OK, msg);
                                    }
                                }
                                else
                                {
                                    if (result.HasError)
                                    {
                                        retValue = Request.CreateResponseMessage(result.Error.Message, ResponseMessageTypes.Info);
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        if (m_resultDDT.HasError)
                        {
                            retValue = Request.CreateResponseMessage(m_resultDDT.Error.Message, ResponseMessageTypes.Info);
                        }
                    }

                    scope.Complete();
                }
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage SalvaDatiDocumentoCaricoCliente(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            Guid m_idFornitore = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.data.Fornitore.ToString()));
            Guid m_idCustomer = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.data.Customer.ToString()));
            Guid m_idTipoDoc = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.data.TipoDocumento.ToString()));

            string m_note = json.data.Note.ToString();

            DateTime m_dataDocumento = DateTime.ParseExact(json.data.DataDocumento.ToString(), "dd/MM/yyyy", CultureInfo.CurrentCulture);

            DateTime m_dataMovimento = DateTime.Now;
            string m_dataMovimentoS = json.data.DataMovimento.ToString();
            if (!string.IsNullOrWhiteSpace(m_dataMovimentoS))
            {
                m_dataMovimento = DateTime.Parse(m_dataMovimentoS);
                //m_dataMovimento = ConvertDateTimeFromGMT(json.data.DataMovimento.ToString(), "(ora legale Europa occidentale),(ora solare Europa occidentale)");
            }

            using (TransactionScope scope = new TransactionScope())
            {
                FCD_AnagraficaDocumenti m_anagDdt = new FCD_AnagraficaDocumenti();
                m_anagDdt.Id = Guid.NewGuid();
                m_anagDdt.NumeroDocumento = json.data.NumeroDocumento;
                m_anagDdt.DataDocumento = m_dataDocumento;
                m_anagDdt.Customer = m_idCustomer;
                m_anagDdt.TipoDocumento = m_idTipoDoc;

                ReturnValue<bool> m_resultDDT = null;
                using (AnagraficaDocumentiFacade m_addt = AnagraficaDocumentiFacade.Create())
                {
                    m_resultDDT = m_addt.Add(m_anagDdt);

                    if (m_resultDDT.HasValue)
                    {
                        if (m_resultDDT.Value)
                        {
                            using (MovimentiFacade m_dc = MovimentiFacade.Create())
                            {
                                // creo il movimento di carico...
                                FCD_Movimenti m_mov = new FCD_Movimenti();
                                m_mov.Id = Guid.NewGuid();
                                m_mov.IdDdt = m_anagDdt.Id;
                                m_mov.NumeroDocumento = json.data.NumeroDocumento;
                                m_mov.DataRegistrazione = DateTime.Now;
                                m_mov.DataMovimento = m_dataMovimento;
                                m_mov.TipoOperazione = (short)TipoOperazione.Deposito;
                                m_mov.TipoMovimento = (short)TipoMovimento.OrdineCarico;
                                m_mov.Customer = m_idCustomer;
                                m_mov.Note = m_note;
                                
                                /* Sezione relativa al movimento di carico effettuato da un cliente */
                                m_mov.RegistratoDaUtente = true;
                                m_mov.DataRegistrazioneUtente = DateTime.Now;
                                /* Sezione relativa al movimento di carico effettuato da un cliente */

                                ReturnValue<bool> result = m_dc.Add(m_mov);

                                if (result.HasValue)
                                {
                                    if (result.Value)
                                    {
                                        ObjectIdentifierBag bag = new ObjectIdentifierBag(m_mov.Id);
                                        string msg = JsonConvert.SerializeObject(bag);
                                        retValue = Request.CreateResponse(HttpStatusCode.OK, msg);
                                    }
                                }
                                else
                                {
                                    if (result.HasError)
                                    {
                                        retValue = Request.CreateResponseMessage(result.Error.Message, ResponseMessageTypes.Info);
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        if (m_resultDDT.HasError)
                        {
                            retValue = Request.CreateResponseMessage(m_resultDDT.Error.Message, ResponseMessageTypes.Info);
                        }
                    }

                    scope.Complete();
                }
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage SalvaDatiDocumentoCarico(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            //Guid m_idFornitore = Guid.Empty;
            //if (!string.IsNullOrWhiteSpace(json.data.CodiceFornitore.ToString()))
            //{
            //    Guid m_codiceFornitore = Guid.Parse(json.data.CodiceFornitore.ToString());
            //    using (CodiciFornitoriFacade m_cff = CodiciFornitoriFacade.Create())
            //    {
            //        ReturnValue<FCD_CodiciFornitori> m_codiceFornitoreRes = m_cff.Get(m_codiceFornitore);
            //        if (m_codiceFornitoreRes.HasValue && m_codiceFornitoreRes.Value != null)
            //        {
            //            FCD_CodiciFornitori m_codiceFornitoreObj = m_codiceFornitoreRes.Value;
            //            m_idFornitore = m_codiceFornitoreObj.IdFornitore;
            //        }
            //    }

            //    m_idFornitore = Guid.Parse(json.data.Fornitore.ToString());
            //}
            
            //
            Guid m_idCustomer = Guid.Parse(json.data.Customer.ToString());
            Guid m_idTipoDoc = Guid.Parse(json.data.TipoDocumento.ToString());
            
            string m_note = json.data.NoteDistinta.ToString();
            
            DateTime m_dataDocumento = DateTime.Parse(json.data.DataDocumento.ToString());

            DateTime m_dataMovimento = DateTime.Now;
            string m_dataMovimentoS = json.data.DataMovimento.ToString();
            if (!string.IsNullOrWhiteSpace(m_dataMovimentoS))
            {
                m_dataMovimento = DateTime.Parse(m_dataMovimentoS);
            }

            using (TransactionScope scope = new TransactionScope())
            {
                FCD_AnagraficaDocumenti m_anagDdt = new FCD_AnagraficaDocumenti();
                m_anagDdt.Id = Guid.NewGuid();
                m_anagDdt.NumeroDocumento = json.data.NumeroDocumento;
                m_anagDdt.DataDocumento = m_dataDocumento;
                m_anagDdt.Customer = m_idCustomer;
                m_anagDdt.TipoDocumento = m_idTipoDoc;

                ReturnValue<bool> m_resultDDT = null;
                using (AnagraficaDocumentiFacade m_addt = AnagraficaDocumentiFacade.Create())
                {
                    m_resultDDT = m_addt.Add(m_anagDdt);

                    if (m_resultDDT.HasValue)
                    {
                        if (m_resultDDT.Value)
                        {
                            using (MovimentiFacade m_dc = MovimentiFacade.Create())
                            {
                                // creo il movimento di carico...
                                FCD_Movimenti m_mov = new FCD_Movimenti();
                                m_mov.Id = Guid.NewGuid();
                                m_mov.IdDdt = m_anagDdt.Id;
                                m_mov.NumeroDocumento = json.data.NumeroDocumento;
                                m_mov.DataRegistrazione = DateTime.Now;
                                m_mov.DataMovimento = m_dataMovimento;
                                m_mov.TipoOperazione = (short)TipoOperazione.Deposito;
                                m_mov.TipoMovimento = (short)TipoMovimento.Carico;
                                m_mov.Customer = m_idCustomer;
                                m_mov.Note = m_note;

                                ReturnValue<bool> result = m_dc.Add(m_mov);

                                if (result.HasValue)
                                {
                                    if (result.Value)
                                    {
                                        ObjectIdentifierBag bag = new ObjectIdentifierBag(m_mov.Id);
                                        string msg = JsonConvert.SerializeObject(bag);
                                        retValue = Request.CreateResponse(HttpStatusCode.OK, msg);
                                    }
                                }
                                else
                                {
                                    if (result.HasError)
                                    {
                                        retValue = Request.CreateResponseMessage(result.Error.Message, ResponseMessageTypes.Info);
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        if (m_resultDDT.HasError)
                        {
                            retValue = Request.CreateResponseMessage(m_resultDDT.Error.Message, ResponseMessageTypes.Info);
                        }
                    }

                    scope.Complete();
                }
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage SalvaElementoCarico(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            using (TransactionScope scope = new TransactionScope())
            {
                using (MovimentoDettaglioFacade m_mdf = MovimentoDettaglioFacade.Create())
                {
                    Guid m_idArticolo = Guid.Parse(json.data.Articolo.ToString());
                    decimal m_quantita = json.data.Quantita;
                    string m_noteDettaglio = json.data.Note;

                    decimal? m_qtaFatt = null;
                    if (json.data.QtaFatt != null)
                    {
                        m_qtaFatt = json.data.QtaFatt;
                    }

                    Guid? m_idFornitore = null;
                    Guid m_codiceFornitore = Guid.Empty;
                    if(json.data.CodiceFornitore != null)
                    {
                        m_codiceFornitore = Guid.Parse(json.data.CodiceFornitore.ToString());

                        using (CodiciFornitoriFacade m_cff = CodiciFornitoriFacade.Create())
                        {
                            ReturnValue<Guid> m_fornRes = m_cff.GetFornitore(m_codiceFornitore);
                            if (m_fornRes.HasValue && m_fornRes.Value != Guid.Empty)
                            {
                                m_idFornitore = m_fornRes.Value;
                            }
                        }
                    }

                    FCD_MovimentiDettaglio m_movD = new FCD_MovimentiDettaglio();
                    m_movD.Articolo = m_idArticolo;
                    m_movD.Id = Guid.NewGuid();
                    m_movD.IdMovimento = json.idMovimento;
                    m_movD.Quantita = m_quantita;
                    m_movD.QuantitaDisponibile = m_quantita;
                    m_movD.QtaFatt = m_qtaFatt;
                    m_movD.Fornitore = m_idFornitore;
                    m_movD.Note = m_noteDettaglio;

                    m_movD.FLotto = 0;
                    if (m_qtaFatt.HasValue)
                    {
                        m_movD.FLotto = m_qtaFatt / m_quantita;
                    }

                    ReturnValue<bool> resultD = m_mdf.Add(m_movD);

                    if (resultD.HasValue)
                    {
                        // verifico se è stato inserito un codice fornitore e provvedo a
                        // registralo per l'articolo, se necessario...
                        if (m_codiceFornitore != Guid.Empty)
                        {
                            using (CodiciFornitoriFacade m_cff = CodiciFornitoriFacade.Create())
                            {
                                m_cff.SaveAssociazioneArticoli(m_idArticolo, m_codiceFornitore, TipoAssociazioneCodiceFornitore.New);
                            }
                        }

                        NameValue<string, Guid> m_resp = new NameValue<string, Guid>();
                        m_resp.value = m_movD.Id;
                        m_resp.name = "Carico Effettuato";
                        retValue = Request.CreateResponse(HttpStatusCode.OK, m_resp);
                        //retValue = Request.CreateResponseMessage("Carico Effettuato", ResponseMessageTypes.Info);
                    }
                    else
                    {
                        if (resultD.HasError)
                        {
                            NameValue<string, Guid> m_resp = new NameValue<string, Guid>();
                            m_resp.value = Guid.Empty;
                            m_resp.name = resultD.Error.Message;
                            retValue = Request.CreateResponse(HttpStatusCode.NotAcceptable, m_resp);

                            //retValue = Request.CreateResponseMessage(resultD.Error.Message, ResponseMessageTypes.Error);
                        }
                    }
                }

                scope.Complete();
            }

            return retValue;
        }

        /// <summary>
        /// Cancella un elemento dalla lista di carico...
        /// </summary>
        /// <param name="data">The data.</param>
        /// <returns></returns>
        /// <remarks>
        /// Durante il carico posso voler cancellare un elemento della lista di carico che sto componendo.
        /// La cancellazione non è mai fisica ma sempre logica.
        /// Per cancellare il singono elemento della lista di carico utilizzo la classe ElaborazioneMovimentiManager
        /// che si preoccupa di effettuare tutti i controlli necessari prima di effettuare la cancellazione...
        /// </remarks>
        [HttpPost]
        public System.Net.Http.HttpResponseMessage CancellaElementoCarico(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            using (MovimentoDettaglioFacade m_mdf = MovimentoDettaglioFacade.Create())
            {
                Guid m_idMovimento = Guid.Parse(json.IdMovimento.ToString());
                Guid m_id = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.data.Id.ToString()));

                ReturnValue<FCD_MovimentiDettaglio> returnMovD = m_mdf.Get(m_id); //(m_idMovimento, m_idArticolo);

                if (returnMovD.HasValue && returnMovD.Value != null)
                {
                    ElaborazioneMovimentiManager m_emm = new ElaborazioneMovimentiManager();

                    ReturnValue<bool> m_resultDel = m_emm.CancellaElementoCarico(m_id); //returnMovD.Value.Id);

                    if (m_resultDel.HasValue)
                    {
                        if (m_resultDel.Value)
                        {
                            m_resultDel.Message = "Elemento Cancellato";
                            retValue = Request.CreateResponse(HttpStatusCode.OK, m_resultDel);
                        }
                        else
                        {
                            retValue = Request.CreateResponse(HttpStatusCode.OK, m_resultDel);
                        }
                    }
                    else
                    {
                        if (m_resultDel.HasError)
                        {
                            retValue = Request.CreateResponse(HttpStatusCode.OK, m_resultDel);
                        }
                    }
                }
            }

            return retValue;
        }

        /// <summary>
        /// Cancella un elemento dalla lista di scarico...
        /// </summary>
        /// <param name="data">The data.</param>
        /// <returns></returns>
        /// Durante lo scarico posso voler cancellare un elemento della lista di scarico che sto componendo.
        /// La cancellazione non è mai fisica ma sempre logica.
        /// Per cancellare il singono elemento della lista di scarico utilizzo la classe ElaborazioneMovimentiManager
        /// che si preoccupa di effettuare tutti i controlli necessari e di ripristiinare le quantità scaricate dai
        /// rispettivi documenti di carico prima di effettuare la cancellazione...
        /// </remarks>
        [HttpPost]
        public System.Net.Http.HttpResponseMessage CancellaElementoScarico(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            using (TransactionScope scope = new TransactionScope())
            {
                using (MovimentoDettaglioFacade m_mdf = MovimentoDettaglioFacade.Create())
                {
                    Guid m_idMovimento = Guid.Parse(json.IdMovimento.ToString());
                    Guid m_idArticolo = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.data.IdArticolo.ToString()));
                    Guid m_id = Guid.Parse(FormlyExtensions.SanitizeDropdownItem(json.data.Id.ToString()));

                    ReturnValue<FCD_MovimentiDettaglio> returnMovD = m_mdf.Get(m_id);  //m_idMovimento, m_idArticolo);

                    if (returnMovD.HasValue && returnMovD.Value != null)
                    {
                        ElaborazioneMovimentiManager m_emm = new ElaborazioneMovimentiManager();
                        ReturnValue<bool> m_resultDel = m_emm.CancellaElementoScarico(returnMovD.Value.Id);

                        if (m_resultDel.HasValue)
                        {
                            if (m_resultDel.Value)
                            {
                                m_resultDel.Message = "Elemento Cancellato";
                                retValue = Request.CreateResponse(HttpStatusCode.OK, m_resultDel);
                            }
                            else
                            {
                                retValue = Request.CreateResponse(HttpStatusCode.OK, m_resultDel);
                            }
                        }
                        else
                        {
                            if (m_resultDel.HasError)
                            {
                                retValue = Request.CreateResponse(HttpStatusCode.OK, m_resultDel);
                            }
                        }
                    }
                }

                scope.Complete();
            }

            return retValue;
        }

        /// <summary>
        /// Cancella tutti gli elementi dalla lista di un movimento di scarico...
        /// </summary>
        /// <param name="data">The data.</param>
        /// <returns></returns>
        /// <remarks>
        /// Durante la composizione di un movimento di scarico posso decidere di cancellare tutti gli elementi 
        /// inseriti nella lista di scarico e ripartire con la lista vuota, senza annullare i dati del movimento di scarico
        /// che sto componendo...
        /// </remarks>
        [HttpPost]
        public System.Net.Http.HttpResponseMessage CancellaElementiScarico(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            try
            {
                using (TransactionScope scope = new TransactionScope())
                {
                    Guid m_idMovimento = Guid.Parse(json.IdMovimento.ToString());

                    ElaborazioneMovimentiManager m_emm = new ElaborazioneMovimentiManager();
                    ReturnValue<bool> m_resultDel = m_emm.CancellaElementiScarico(m_idMovimento);

                    if (m_resultDel.HasValue)
                    {
                        retValue = Request.CreateResponseMessage("Elementi cancellati", ResponseMessageTypes.Info);
                    }
                    else
                    {
                        if (m_resultDel.HasError)
                        {
                            retValue = Request.CreateResponseMessage(m_resultDel.Error.Message, ResponseMessageTypes.Error);
                        }
                    }

                    scope.Complete();
                }
            }
            catch (Exception ex)
            {
                retValue = Request.CreateResponseMessage(ex.Message, ResponseMessageTypes.Error);
            }

            return retValue;
        }

        /// <summary>
        /// Cancellagli elementi di un movimento di carico...
        /// </summary>
        /// <param name="data">The data.</param>
        /// <returns></returns>
        /// <remarks>
        /// Durante la composizione di un movimento di ccarico posso decidere di cancellare tutti gli elementi 
        /// inseriti nella lista di ccarico e ripartire con la lista vuota, senza annullare i dati del movimento di carico
        /// che sto componendo...
        /// </remarks>
        [HttpPost]
        public System.Net.Http.HttpResponseMessage CancellaElementiCarico(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            try
            {
                using (TransactionScope scope = new TransactionScope())
                {
                    Guid m_idMovimento = Guid.Parse(json.IdMovimento.ToString());

                    ElaborazioneMovimentiManager m_emm = new ElaborazioneMovimentiManager();
                    ReturnValue<bool> m_resultDel = m_emm.CancellaElementiCarico(m_idMovimento);

                    if (m_resultDel.HasValue)
                    {
                        retValue = Request.CreateResponseMessage("Elementi cancellati", ResponseMessageTypes.Info);
                    }
                    else
                    {
                        if (m_resultDel.HasError)
                        {
                            retValue = Request.CreateResponseMessage(m_resultDel.Error.Message, ResponseMessageTypes.Error);
                        }
                    }

                    scope.Complete();
                }
            }
            catch (Exception ex)
            {
                retValue = Request.CreateResponseMessage(ex.Message, ResponseMessageTypes.Error);
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage CancellaDistintaCarico(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            try
            {
                using (TransactionScope scope = new TransactionScope())
                {
                    Guid m_idMovimento = Guid.Parse(json.IdMovimento.ToString());

                    ElaborazioneMovimentiManager m_emm = new ElaborazioneMovimentiManager();
                    ReturnValue<bool> m_resultDel = m_emm.CancellaDistintaCarico(m_idMovimento);

                    if (m_resultDel.HasValue)
                    {
                        retValue = Request.CreateResponseMessage("Distinta cancellata", ResponseMessageTypes.Info);
                    }
                    else
                    {
                        if (m_resultDel.HasError)
                        {
                            retValue = Request.CreateResponseMessage(m_resultDel.Error.Message, ResponseMessageTypes.Error);
                        }
                    }

                    scope.Complete();
                }
            }
            catch (Exception ex)
            {
                retValue = Request.CreateResponseMessage(ex.Message, ResponseMessageTypes.Error);
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage LoadMovimentiClienteNonAccettati(DTParameters data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            using (MovimentiFacade m_dc = MovimentiFacade.Create())
            {
                ReturnValue<IQueryable<Cronologia>> m_objs = m_dc.GetMovimentiNonAccettatiBags();

                DTResult<Cronologia> result = DTResult<Cronologia>.Empty("Nessun elemento trovato");
                if (m_objs.HasValue)
                {
                    MovimentiResultSet m_rs = new MovimentiResultSet(data, m_objs.Value);
                    result = m_rs.GetResult();
                }
                else
                {
                    if (m_objs.HasError)
                    {
                        result.Message.MessageType = MessageTypes.Error;
                        result.Message.Message = m_objs.Error.Message;
                    }
                }

                retValue = Request.CreateResponse(HttpStatusCode.OK, result);
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage AccettaMovimentoCliente(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            try
            {
                Guid m_idMovimento = Guid.Parse(json.id.ToString());
                int m_tipoMovimento = int.Parse(json.tipoMovimento.ToString());
                string m_name = HttpContext.Current.User.Identity.Name;

                ElaborazioneMovimentiManager m_emm = new ElaborazioneMovimentiManager();
                ReturnValue<bool> m_resultDel = m_emm.AccettaMovimentoCliente(m_idMovimento, m_tipoMovimento, m_name);

                if (m_resultDel.HasValue)
                {
                    retValue = Request.CreateResponseMessage("Movimento Accettato", ResponseMessageTypes.Info);

                    if (m_tipoMovimento == (int)TipoMovimento.OrdineScarico)
                    {
                        retValue = EvadiRichiestaScaricoCliente(m_idMovimento);
                    }
                }
                else
                {
                    if (m_resultDel.HasError)
                    {
                        retValue = Request.CreateResponseMessage(m_resultDel.Error.Message, ResponseMessageTypes.Error);
                    }
                }
            }
            catch (Exception ex)
            {
                retValue = Request.CreateResponseMessage(ex.Message, ResponseMessageTypes.Error);
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage GetMovimentoDetails(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            string m_id = json.Id.ToString();
            if (!string.IsNullOrWhiteSpace(m_id))
            {
                Guid m_idM = Guid.Parse(m_id);

                using (MovimentiFacade m_mf = MovimentiFacade.Create())
                {
                    List<FCD_GetDettaglioMovimentoCaricoReturnModel> m_res = m_mf.GetDettaglioMovimentoCaricoEdit(m_idM);

                    retValue = Request.CreateResponse(HttpStatusCode.OK, m_res);
                }
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage GetMovimentiCaricoToEdit(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            try
            {
                DateTime m_dataMovimento = default(DateTime);
                Guid m_customer = Guid.Empty;
                Guid m_tipoDocumento = Guid.Empty;
                string m_numeroDocumento = string.Empty;
                DateTime m_dataDocumento = default(DateTime);

                if(!string.IsNullOrWhiteSpace(json.data.DataMov))
                {
                    m_dataMovimento = DateTime.Parse(json.data.DataMov.ToString());
                }
                if (!string.IsNullOrWhiteSpace(json.data.Customer.ToString()))
                {
                    m_customer = Guid.Parse(json.data.Customer.ToString());
                }
                if (!string.IsNullOrWhiteSpace(json.data.TipoDocumento.ToString()))
                {
                    m_tipoDocumento = Guid.Parse(json.data.TipoDocumento.ToString());
                }
                if (!string.IsNullOrWhiteSpace(json.data.NumeroDocumento.ToString()))
                {
                    m_numeroDocumento = json.data.NumeroDocumento.ToString();
                }
                if (!string.IsNullOrWhiteSpace(json.data.DataDoc))
                {
                    m_dataDocumento = DateTime.Parse(json.data.DataDoc);
                }

                using (MovimentiFacade m_mf = MovimentiFacade.Create())
                {
                    var predicate = PredicateBuilder.True<FCD_Movimenti>();

                    if (m_dataMovimento != default(DateTime))
                    {
                        predicate = predicate.And(im => DbFunctions.TruncateTime(im.DataMovimento) == DbFunctions.TruncateTime(m_dataMovimento));
                    }
                    if (m_customer != Guid.Empty)
                    {
                        predicate = predicate.And(im => im.Customer == m_customer);
                    }
                    if (m_tipoDocumento != Guid.Empty)
                    {
                        predicate = predicate.And(im => im.FCD_AnagraficaDocumenti.TipoDocumento == m_tipoDocumento);
                    }
                    if (!string.IsNullOrWhiteSpace(m_numeroDocumento))
                    {
                        predicate = predicate.And(im => im.NumeroDocumento.ToLower().Contains(m_numeroDocumento.ToLower()));
                    }
                    if (m_dataDocumento != default(DateTime))
                    {
                        predicate = predicate.And(im => DbFunctions.TruncateTime(im.FCD_AnagraficaDocumenti.DataDocumento) == DbFunctions.TruncateTime(m_dataDocumento));
                    }
                    
                    ReturnValue<List<ModificaMovimentoBag>> m_result = m_mf.CercaMovimentoToEdit(predicate, TipoMovimento.Carico);

                    if (m_result.HasValue)
                    {
                        retValue = Request.CreateResponse(HttpStatusCode.OK, m_result.Value);
                    }
                    else
                    {
                        if (m_result.HasError)
                        {
                            retValue = Request.CreateResponseMessage(m_result.Error.Message, ResponseMessageTypes.Error);
                        }
                    }
                }


            }
            catch (Exception ex)
            {
                retValue = Request.CreateResponseMessage(ex.Message, ResponseMessageTypes.Error);
            }

            return retValue;
        }

        [HttpPost]
        public System.Net.Http.HttpResponseMessage GetMovimentiScaricoToEdit(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            try
            {
                DateTime m_dataMovimento = default(DateTime);
                Guid m_customer = Guid.Empty;
                string m_riferimentoCliente = string.Empty;
                Guid m_tipoDocumento = Guid.Empty;
                string m_numeroDocumento = string.Empty;
                DateTime m_dataDocumento = default(DateTime);
                //int m_colore = default(int);
                string m_colore = string.Empty;

                if (!string.IsNullOrWhiteSpace(json.data.DataMov))
                {
                    m_dataMovimento = DateTime.Parse(json.data.DataMov.ToString());
                }
                if (!string.IsNullOrWhiteSpace(json.data.Customer.ToString()))
                {
                    m_customer = Guid.Parse(json.data.Customer.ToString());
                }
                if (!string.IsNullOrWhiteSpace(json.data.RiferimentoCliente.ToString()))
                {
                    m_riferimentoCliente = Guid.Parse(json.data.RiferimentoCliente.ToString());
                }
                if (!string.IsNullOrWhiteSpace(json.data.TipoDocumento.ToString()))
                {
                    m_tipoDocumento = Guid.Parse(json.data.TipoDocumento.ToString());
                }
                if (!string.IsNullOrWhiteSpace(json.data.NumeroDocumento.ToString()))
                {
                    m_numeroDocumento = json.data.NumeroDocumento.ToString();
                }
                if (!string.IsNullOrWhiteSpace(json.data.DataDoc))
                {
                    m_dataDocumento = DateTime.Parse(json.data.DataDoc);
                }
                if (!string.IsNullOrWhiteSpace(json.data.Colore))
                {
                    //m_colore = int.Parse(json.data.Colore.ToString().Replace("string:", ""));
                    m_colore = json.data.Colore.ToString();
                }


                using (MovimentiFacade m_mf = MovimentiFacade.Create())
                {
                    var predicate = PredicateBuilder.True<FCD_Movimenti>();

                    if (m_dataMovimento != default(DateTime))
                    {
                        predicate = predicate.And(im => DbFunctions.TruncateTime(im.DataMovimento) == DbFunctions.TruncateTime(m_dataMovimento));
                    }
                    if (m_customer != Guid.Empty)
                    {
                        predicate = predicate.And(im => im.Customer == m_customer);
                    }
                    if (!string.IsNullOrWhiteSpace(m_riferimentoCliente))
                    {
                        predicate = predicate.And(im => im.RiferimentoCliente.ToLower().Contains(m_riferimentoCliente.ToLower()));
                    }
                    if (m_tipoDocumento != Guid.Empty)
                    {
                        predicate = predicate.And(im => im.FCD_AnagraficaDocumenti.TipoDocumento == m_tipoDocumento);
                    }
                    if (!string.IsNullOrWhiteSpace(m_numeroDocumento))
                    {
                        predicate = predicate.And(im => im.NumeroDocumento.ToLower().Contains(m_numeroDocumento.ToLower()));
                    }
                    if (m_dataDocumento != default(DateTime))
                    {
                        predicate = predicate.And(im => DbFunctions.TruncateTime(im.FCD_AnagraficaDocumenti.DataDocumento) == DbFunctions.TruncateTime(m_dataDocumento));
                    }
                    //if (m_colore != default(int))
                    //{
                    //    predicate = predicate.And(im => im.FCD_MovimentiDettaglios.Any(x=>x.Colore == m_colore));
                    //}
                    if (!string.IsNullOrWhiteSpace(m_colore))
                    {
                        predicate = predicate.And(im => im.FCD_MovimentiDettaglios.Any(x => x.CodiceColore == m_colore));
                    }

                    ReturnValue<List<ModificaMovimentoBag>> m_result = m_mf.CercaMovimentoToEdit(predicate, TipoMovimento.Scarico);

                    if (m_result.HasValue)
                    {
                        retValue = Request.CreateResponse(HttpStatusCode.OK, m_result.Value);
                    }
                    else
                    {
                        if (m_result.HasError)
                        {
                            retValue = Request.CreateResponseMessage(m_result.Error.Message, ResponseMessageTypes.Error);
                        }
                    }
                }


            }
            catch (Exception ex)
            {
                retValue = Request.CreateResponseMessage(ex.Message, ResponseMessageTypes.Error);
            }

            return retValue;
        }

        /// <summary>
        /// Se durante un carico viene modificato il fornitore di un articolo a cui è già stato associato un differente fornitore,
        /// allora bisogna ciclare per aggiornare il fornitore di tutte le occorrenze dell'articolo nel movimento di carico specifico,
        /// cioè a livello del solo movimento di carico per il quale si modifica il fornitore dell'articolo
        /// </summary>
        /// <param name="data">The data.</param>
        /// <returns></returns>
        [HttpPost]
        public System.Net.Http.HttpResponseMessage AggiornaFornitoriElementoCarico(JObject data)
        {
            System.Net.Http.HttpResponseMessage retValue = new HttpResponseMessage(HttpStatusCode.InternalServerError);

            dynamic json = data;

            try
            {
                Console.WriteLine(json);
            }
            catch (Exception ex)
            {
                retValue = Request.CreateResponseMessage(ex.Message, ResponseMessageTypes.Error);
            }

            return retValue;
        }
    }
}